package com.jeff.huawei.practice;
/*
*
* VLAN是一种对局域网设备进行逻辑划分的技术，为了标识
不同的VLAN,引入VLAN ID(1-4094之间的整数)的概念。
定义一个VLAN ID的资源池（下称VLAN资源池），资源池中连
续的VLAN用开始VLAN-结束VLAN表示，不连续的用单个整
数表示，所有的VLAN用英文逗号连接起来。现在有一个
VLAN资源池，业务需要从资源池中申请一个VLAN,需要你
输出从VLAN资源池中移除申请的VLAN后的资源池。
*
* 输入描述
第一行为字符串格式的VLAN资源池，第二行为业务要申请的VLAN,VLAN的取值范围为
[1,4094]之间的整数。
输出描述
从输入VLAN资源池中移除申请的VLAN后字符串格式的VLAN资源池，输出要求
满足题目描述中的格式，并且按照VLAN从小到大升序输出。
如果申清的VLAN不在原VLAN资源池内，输出原VLAN资源池升序排序后的字符
串即可。
补充说明
输入VLAN资源池中VLAN的数量取值范围为[2-4094]间的整数，资源池中VLAN不重复且合
法([1,4094]之间的整数)，输入是乱序的。
示例1
收起入
输入

1-5
2
输出

1,3-5
说明
原VLAN资源池中有VLAN1、2、3、4、5,从资源池中移除2后，剩下VLAN1、3、4、
5,按照题目描述格式并升序后的结果为1,3-5。
)示例2
收起人
输入
复制
20-21,15,18,30,5-10
15
输出
复制
5-10,18,20-21,30
说明
原VLAN资源池中有VLAN5、6、7、8、9、10、15、18、20、21、30,从资源池中移
除15后，资源池中剩下的VLAN为5、6、7、8、9、10、18、20、21、30，按照题目描
述格式并升序后的结果为5-10,18,20-21,30。 */
import java.util.*;

public class Test1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取VLAN资源池
        String vlanPoolInput = scanner.nextLine();
        // 读取要申请的VLAN
        int vlanToRemove = Integer.parseInt(scanner.nextLine());

        // 解析VLAN资源池
        List<VLANRange> vlanRanges = parseVLANPool(vlanPoolInput);

        // 移除指定的VLAN
        removeVLAN(vlanRanges, vlanToRemove);

        // 格式化并输出结果
        String result = formatVLANPool(vlanRanges);
        System.out.println(result);

        scanner.close();
    }

    // 解析VLAN资源池字符串为VLANRange列表
    private static List<VLANRange> parseVLANPool(String vlanPool) {
        List<VLANRange> ranges = new ArrayList<>();
        String[] parts = vlanPool.split(",");
        for (String part : parts) {
            if (part.contains("-")) {
                String[] rangeParts = part.split("-");
                int start = Integer.parseInt(rangeParts[0]);
                int end = Integer.parseInt(rangeParts[1]);
                ranges.add(new VLANRange(start, end));
            } else {
                ranges.add(new VLANRange(Integer.parseInt(part), Integer.parseInt(part)));
            }
        }
        return ranges;
    }

    // 移除指定的VLAN
    private static void removeVLAN(List<VLANRange> ranges, int vlan) {
        Iterator<VLANRange> iterator = ranges.iterator();
        while (iterator.hasNext()) {
            VLANRange range = iterator.next();
            if (range.start <= vlan && vlan <= range.end) {
                if (range.start == range.end) {
                    iterator.remove();
                } else if (vlan == range.start) {
                    range.start++;
                } else if (vlan == range.end) {
                    range.end--;
                } else {
                    // 分裂范围
                    VLANRange newRange = new VLANRange(vlan + 1, range.end);
                    range.end = vlan - 1;
                    ranges.add(newRange);
                }
            }
        }
    }

    // 格式化VLAN资源池为字符串
    private static String formatVLANPool(List<VLANRange> ranges) {
        Collections.sort(ranges);
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < ranges.size(); i++) {
            VLANRange range = ranges.get(i);
            if (i > 0) {
                sb.append(",");
            }
            if (range.start == range.end) {
                sb.append(range.start);
            } else {
                sb.append(range.start).append("-").append(range.end);
            }
        }
        return sb.toString();
    }

    // VLAN范围类
    static class VLANRange implements Comparable<VLANRange> {
        int start;
        int end;

        VLANRange(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public int compareTo(VLANRange other) {
            return Integer.compare(this.start, other.start);
        }
    }
}
